home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / ghostscript / 8.64 / Resource / Init / gs_res.ps < prev    next >
Encoding:
Text File  |  2009-04-17  |  36.6 KB  |  1,119 lines
  1. %    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_res.ps 8954 2008-08-08 04:22:38Z ray $
  17. % Initialization file for Level 2 resource machinery.
  18. % When this is run, systemdict is still writable,
  19. % but (almost) everything defined here goes into level2dict.
  20.  
  21. level2dict begin
  22.  
  23. (BEGIN RESOURCES) VMDEBUG
  24.  
  25. % We keep track of (global) instances with another entry in the resource
  26. % dictionary, an .Instances dictionary.  For categories with implicit
  27. % instances, the values in .Instances are the same as the keys;
  28. % for other categories, the values are [instance status size].
  29.  
  30. % Note that the dictionary that defines a resource category is stored
  31. % in global VM.  The PostScript manual says that each category must
  32. % manage global and local instances separately.  However, objects in
  33. % global VM other than systemdict can't reference objects in local VM.
  34. % This means that the resource category dictionary, which would otherwise be
  35. % the obvious place to keep track of the instances, can't be used to keep
  36. % track of local instances.  Instead, we define a dictionary in local VM
  37. % called localinstancedict, in which the key is the category name and
  38. % the value is the analogue of .Instances for local instances.
  39.  
  40. % We don't currently implement automatic resource unloading.
  41. % When and if we do, it should be hooked to the garbage collector.
  42. % However, Ed Taft of Adobe says their interpreters don't implement this
  43. % either, so we aren't going to worry about it for a while.
  44.  
  45. currentglobal false setglobal systemdict begin
  46.   /localinstancedict 5 dict
  47.   .forcedef    % localinstancedict is local, systemdict is global
  48. end true setglobal
  49. /.emptydict 0 dict readonly def
  50. setglobal
  51.  
  52. % Resource category dictionaries have the following keys (those marked with
  53. % * are optional):
  54. %    Standard, defined in the Red Book:
  55. %        Category (name)
  56. %        *InstanceType (name)
  57. %        DefineResource
  58. %            <key> <instance> DefineResource <instance>
  59. %        UndefineResource
  60. %            <key> UndefineResource -
  61. %        FindResource
  62. %            <key> FindResource <instance>
  63. %        ResourceStatus
  64. %            <key> ResourceStatus <status> <size> true
  65. %            <key> ResourceStatus false
  66. %        ResourceForAll
  67. %            <template> <proc> <scratch> ResourceForAll -
  68. %        *ResourceFileName
  69. %            <key> <scratch> ResourceFileName <filename>
  70. %    Additional, specific to our implementation:
  71. %        .Instances (dictionary)
  72. %        .LocalInstances
  73. %            - .LocalInstances <dict>
  74. %        .GetInstance
  75. %            <key> .GetInstance <instance> -true-
  76. %            <key> .GetInstance -false-
  77. %        .CheckResource
  78. %            <key> <value> .CheckResource <key> <value> <ok>
  79. %              (or may give an error if not OK)
  80. %        .DoLoadResource
  81. %            <key> .DoLoadResource <key> (may give an error)
  82. %        .LoadResource
  83. %            <key> .LoadResource - (may give an error)
  84. %        .ResourceFile
  85. %            <key> .ResourceFile <file> -true-
  86. %            <key> .ResourceFile <key> -false-
  87. %        .ResourceFileStatus
  88. %            <key> .ResourceFileStatus 2 <vmusage> -true-
  89. %            <key> .ResourceFileStatus -false-
  90. % All the above procedures expect that the top dictionary on the d-stack
  91. % is the resource dictionary.
  92.  
  93. % Define enough of the Category category so we can define other categories.
  94. % The dictionary we're about to create will become the Category
  95. % category definition dictionary.
  96.  
  97. % .findcategory and .resourceexec are only called from within the
  98. % implementation of the resource 'operators', so they don't have to worry
  99. % about cleaning up the stack if they fail (the interpreter's stack
  100. % protection machinery for pseudo-operators takes care of this).
  101. % Note that all places that look up categories must use .findcategory
  102. % so that the command in case of error will be correct rather than an
  103. % internal invocation of findresource.
  104. /.findcategory {    % <name> .findcategory -
  105.             %   (pushes the category on the dstack)
  106.     /Category .findresource begin    % note: *not* findresource
  107. } bind def
  108.  
  109. % If an error occurs within the logic of a resource operator (after operand
  110. % acquisition and checking), the Adobe interpreters report the operator name,
  111. % not the operator object, as the command in $error.  For this reason, and
  112. % this reason only, all resource operators must wrap their logic code in
  113. %    /<opername> cvx { ...logic... } .errorexec
  114.  
  115. % The Category resource signals /undefined rather than /undefinedresource,
  116. % both when referenced implicitly (to look up the category for a general
  117. % resource operation) and when it is accessed directly (/Category /xxx
  118. % findresource).  Because of this, all resource operators must use
  119. % .undefinedresource rather than signalling undefinedresource directly.
  120. /.undefinedresource {    % <command> .undefinedresource -
  121.     /Category dup load eq { /undefined } { /undefinedresource } ifelse
  122.     signaloperror
  123. } bind def
  124.  
  125. /.resourceexec {    % <key> /xxxResource .resourceexec -
  126.             %   (also pops the category from the dstack)
  127.   load exec end
  128. } bind def
  129.  
  130. % .getvminstance treats instances on disk as undefined.
  131. /.getvminstance {    % <key> .getvminstance <instance> -true-
  132.             % <key> .getvminstance -false-
  133.   .GetInstance {
  134.     dup 1 get 2 ne { true } { pop false } ifelse
  135.   } {
  136.     false
  137.   } ifelse
  138. } bind def
  139.  
  140. 20 dict begin
  141.  
  142.         % Standard entries
  143.  
  144. /Category /Category def
  145. /InstanceType /dicttype def
  146.  
  147. /DefineResource {
  148.     .CheckResource {
  149.       dup /Category 3 index cvlit .growput
  150.       dup [ exch 0 -1 ] exch
  151.       .Instances 4 2 roll put
  152.         % Make the Category dictionary read-only.  We will have to
  153.         % use .forceput / .forcedef later to replace the dummy,
  154.         % empty .Instances dictionary with the real one later.
  155.       readonly
  156.     } {
  157.       /defineresource cvx /typecheck signaloperror
  158.     } ifelse
  159. } bind def
  160. /FindResource        % (redefined below)
  161.     { .Instances exch get 0 get
  162.     } bind def
  163.  
  164.         % Additional entries
  165.  
  166. /.Instances 30 dict def
  167. .Instances /Category [currentdict 0 -1] put
  168.  
  169. /.LocalInstances 0 dict def
  170. /.GetInstance
  171.     { .Instances exch .knownget
  172.     } bind def
  173. /.CheckResource
  174.     { dup gcheck currentglobal and
  175.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  176.          /UndefineResource }
  177.        { 2 index exch known and }
  178.       forall
  179.       not { /defineresource cvx /invalidaccess signaloperror } if
  180.       true
  181.     } bind def
  182.  
  183. .Instances end begin    % for the base case of findresource
  184.  
  185. (END CATEGORY) VMDEBUG
  186.  
  187. % Define the resource operators.  We use the "stack protection" feature of
  188. % odef to make sure the stacks are restored properly on an error.
  189. % This requires that the operators not pop anything from the stack until
  190. % they have executed their logic successfully.  We can't make this
  191. % work for resourceforall, because the procedure it executes mustn't see
  192. % the operands of resourceforall on the stack, but we can make it work for
  193. % the others.
  194.  
  195. % findresource is the only operator that needs to bind //Category.
  196. % We define its contents as a separate procedure so that .findcategory
  197. % can use it without entering another level of pseudo-operator.
  198. /.findresource {        % <key> <category> findresource <instance>
  199.     2 copy dup /Category eq
  200.       { pop //Category 0 get begin } { .findcategory } ifelse
  201.     /FindResource .resourceexec exch pop exch pop
  202. } bind
  203. end        % .Instances of Category
  204. def
  205. /findresource {
  206.     % See above re .errorexec.
  207.     1 .argindex     % also catch stackunderflow
  208.     dup type /stringtype eq { cvn } if  % for CET 23-13-04
  209.     3 1 roll exch pop
  210.     dup type /nametype ne {
  211.       /findresource .systemvar /typecheck signalerror
  212.     } if
  213.     /findresource cvx //.findresource .errorexec
  214. } odef
  215.  
  216. /defineresource {    % <key> <instance> <category> defineresource <instance>
  217.     2 .argindex 2 index 2 index    % catch stackunderflow
  218.     % See above re .errorexec.
  219.     /defineresource cvx {
  220.     .findcategory
  221.     currentdict /InstanceType known {
  222.       dup type InstanceType ne {
  223.         dup type /packedarraytype eq InstanceType /arraytype eq and
  224.         not { /defineresource cvx /typecheck signaloperror } if
  225.       } if
  226.     } if
  227.     /DefineResource .resourceexec
  228.     4 1 roll pop pop pop
  229.     } .errorexec
  230. } bind odef
  231. % We must prevent resourceforall from automatically restoring the stacks,
  232. % because we don't want the stacks restored if proc causes an error or
  233. % executes a 'stop'. On the other hand, resourceforall is defined in the
  234. % PLRM as an operator, so it must have type /operatortype.  We hack this
  235. % by taking advantage of the fact that the interpreter optimizes tail
  236. % calls, so stack protection doesn't apply to the very last token of an
  237. % operator procedure.
  238. /resourceforall1 {    % <template> <proc> <scratch> <category> resourceforall1 -
  239.     dup .findcategory
  240.     /ResourceForAll load
  241.     % Stack: <template> <proc> <scratch> <category> proc
  242.     exch pop        % pop the category
  243.     exec end
  244. } bind def
  245. /resourceforall {    % <template> <proc> <scratch> <category> resourceforall1 -
  246.     //resourceforall1 exec        % see above
  247. } bind odef
  248. /resourcestatus {    % <key> <category> resourcestatus <status> <size> true
  249.             % <key> <category> resourcestatus false
  250.   {
  251.     0 .argindex type /nametype ne {
  252.       % CET 23-26 wants typecheck here, not undefineresource that happens
  253.       % without the check.
  254.       /resourcestatus cvx /typecheck signalerror
  255.     } if
  256.     2 copy .findcategory /ResourceStatus .resourceexec
  257.     { 4 2 roll pop pop true } { pop pop false } ifelse
  258.   } stopped {
  259.     % Although resourcestatus is an operator, Adobe uses executable name
  260.     % for error reporting. CET 23-26
  261.     /resourcestatus cvx $error /errorname get signalerror
  262.   } if
  263. } bind odef
  264. /undefineresource {    % <key> <category> undefineresource -
  265.   0 .argindex type /nametype ne {
  266.     /undefinedresource cvx /typecheck signaloperror
  267.   } if
  268.   1 .argindex 1 index        % catch stackunderflow
  269.  
  270.   { .findcategory /UndefineResource .resourceexec pop pop
  271.   } stopped {
  272.     % Although undefineresource is an operator, Adobe uses executable name
  273.     % here but uses operator for the errors above. CET 23-33
  274.     /undefineresource cvx $error /errorname get signalerror
  275.   } if
  276. } bind odef
  277.  
  278. % Define the system parameters used for the Generic implementation of
  279. % ResourceFileName.
  280. systemdict begin
  281.  
  282. %     - .default_resource_dir <string>
  283. /.default_resource_dir {
  284.   /LIBPATH .systemvar {
  285.     dup .file_name_current eq {
  286.       pop
  287.     } {
  288.       (Resource) search {
  289.         exch concatstrings
  290.         exch 0 1 getinterval concatstrings exit
  291.       } {
  292.         pop
  293.       } ifelse
  294.     } ifelse
  295.   } forall
  296. } bind def
  297.  
  298. %  <path> <name> <string> .resource_dir_name <path> <name> <string>
  299. /.resource_dir_name
  300. {  systemdict 2 index .knownget {
  301.      exch pop
  302.      systemdict 1 index undef
  303.    } {
  304.      dup () ne {
  305.      .file_name_directory_separator concatstrings
  306.     } if
  307.     2 index exch false .file_name_combine not {
  308.       (Error: .default_resource_dir returned ) print exch print ( that can't combine with ) print =
  309.       /.default_resource_dir cvx /configurationerror signalerror
  310.     } if
  311.   } ifelse
  312. } bind def
  313.  
  314. currentdict /pssystemparams known not {
  315.   /pssystemparams 10 dict readonly def
  316. } if
  317. pssystemparams begin
  318.   .default_resource_dir
  319.   /FontResourceDir (Font) .resource_dir_name
  320.      readonly .forcedef    % pssys'params is r-o
  321.   /GenericResourceDir () .resource_dir_name
  322.      readonly .forcedef    % pssys'params is r-o
  323.   pop % .default_resource_dir
  324.   /GenericResourcePathSep
  325.       .file_name_separator readonly .forcedef        % pssys'params is r-o
  326.   (%diskFontResourceDir) cvn (/Resource/Font/) readonly .forcedef    % pssys'params is r-o
  327.   (%diskGenericResourceDir) cvn (/Resource/) readonly .forcedef    % pssys'params is r-o
  328. end
  329. end
  330.  
  331. % Check if GenericResourceDir presents in LIBPATH.
  332.  
  333. % The value of GenericResourceDir must end with directory separator.
  334. % We use .file_name_combine to check it. 
  335. % Comments use OpenVMS syntax, because it is the most complicated case.
  336. (x) pssystemparams /GenericResourcePathSep get
  337. (y) concatstrings concatstrings dup length              % (x]y) l1
  338. pssystemparams /GenericResourceDir get dup length exch  % (x]y) l1 l2 (dir)
  339. 3 index true .file_name_combine not {
  340.   exch
  341.   (File name ) print print ( cant combine with ) print =
  342.   /GenericResourceDir cvx /configurationerror signaloperror
  343. } if
  344. dup length                                              % (x]y) l1 l2 (dir.x]y) l
  345. 4 2 roll add                                            % (x]y) (dir.x]y) l ll
  346. ne {
  347.   (GenericResourceDir value does not end with directory separator.\n) =
  348.   /GenericResourceDir cvx /configurationerror signaloperror
  349. } if
  350. pop pop
  351.  
  352. % Define the generic algorithm for computing resource file names.
  353. /.rfnstring 8192 string def
  354. /.genericrfn        % <key> <scratch> <prefix> .genericrfn <filename>
  355.  { 3 -1 roll //.rfnstring cvs concatstrings exch copy
  356.  } bind def
  357.  
  358. % Define the Generic category.
  359.  
  360. /Generic mark
  361.  
  362.         % Standard entries
  363.  
  364. % We're still running in Level 1 mode, so dictionaries won't expand.
  365. % Leave room for the /Category entry.
  366. /Category null
  367.  
  368. % Implement the body of Generic resourceforall for local, global, and
  369. % external cases.  'args' is [template proc scratch resdict].
  370. /.enumerateresource {    % <key> [- <proc> <scratch>] .enumerateresource -
  371.   1 index type dup /stringtype eq exch /nametype eq or {
  372.     exch 1 index 2 get cvs exch
  373.   } if
  374.     % Use .setstackprotect to prevent the stacks from being restored if
  375.     % an error occurs during execution of proc.
  376.   1 get false .setstackprotect exec true .setstackprotect
  377. } bind def
  378. /.localresourceforall {        % <key> <value> <args> .localr'forall -
  379.   exch pop
  380.   2 copy 0 get .stringmatch { .enumerateresource } { pop pop } ifelse
  381. } bind def
  382. /.globalresourceforall {    % <key> <value> <args> .globalr'forall -
  383.   exch pop
  384.   2 copy 0 get .stringmatch {
  385.     dup 3 get begin .LocalInstances end 2 index known not {
  386.       .enumerateresource
  387.     } {
  388.       pop pop
  389.     } ifelse
  390.   } {
  391.     pop pop
  392.   } ifelse
  393. } bind def
  394. /.externalresourceforall {    % <filename> <len> <args> .externalr'forall -
  395.   3 1 roll 1 index length 1 index sub getinterval exch
  396.   dup 3 get begin .Instances .LocalInstances end
  397.         % Stack: key args insts localinsts
  398.   3 index known {
  399.     pop pop pop
  400.   } {
  401.     2 index known { pop pop } { .enumerateresource } ifelse
  402.   } ifelse
  403. } bind def
  404.  
  405. /DefineResource {
  406.     .CheckResource
  407.        { dup [ exch 0 -1 ]
  408.             % Stack: key value instance
  409.          currentglobal
  410.           { false setglobal 2 index UndefineResource    % remove local def if any
  411.         true setglobal
  412.         .Instances dup //.emptydict eq {
  413.           pop 3 dict
  414.             % As noted above, Category dictionaries are read-only,
  415.             % so we have to use .forcedef here.
  416.           /.Instances 1 index .forcedef    % Category dict is read-only
  417.         } if
  418.           }
  419.           { .LocalInstances dup //.emptydict eq
  420.              { pop 3 dict localinstancedict Category 2 index put
  421.          }
  422.         if
  423.           }
  424.          ifelse
  425.             % Stack: key value instance instancedict
  426.          3 index 2 index .growput
  427.             % Now make the resource value read-only.
  428.          0 2 copy get { readonly } .internalstopped pop
  429.          dup 4 1 roll put exch pop exch pop
  430.        }
  431.        { /defineresource cvx /typecheck signaloperror
  432.        }
  433.     ifelse
  434. } .bind executeonly        % executeonly to prevent access to .forcedef
  435. /UndefineResource
  436.     {  { dup 2 index .knownget
  437.           { dup 1 get 1 ge
  438.          { dup 0 null put 1 2 put pop pop }
  439.          { pop exch .undef }
  440.         ifelse
  441.           }
  442.           { pop pop
  443.           }
  444.          ifelse
  445.        }
  446.       currentglobal
  447.        { 2 copy .Instances exch exec
  448.        }
  449.       if .LocalInstances exch exec
  450.     } bind
  451. % Because of some badly designed code in Adobe's CID font downloader that
  452. % makes findresource and resourcestatus deliberately inconsistent with each
  453. % other, the default FindResource must not call ResourceStatus if there is
  454. % an instance of the desired name already defined in VM.
  455. /FindResource {
  456.     dup //null eq {
  457.           % CET 13-06 wants /typecheck for "null findencoding" but
  458.           % .knownget doesn't fail on null
  459.           /findresource cvx /typecheck signaloperror
  460.         } if
  461.     dup .getvminstance {
  462.       exch pop 0 get
  463.     } {
  464.       dup ResourceStatus {
  465.         pop 1 gt {
  466.           .DoLoadResource .getvminstance not {
  467.         /findresource cvx .undefinedresource
  468.           } if 0 get
  469.         } {
  470.           .GetInstance pop 0 get
  471.         } ifelse
  472.       } {
  473.        /findresource cvx .undefinedresource
  474.       } ifelse
  475.     } ifelse
  476. } bind
  477. % Because of some badly designed code in Adobe's CID font downloader, the
  478. % definition of ResourceStatus for Generic and Font must be the same (!).
  479. % We patch around this by using an intermediate .ResourceFileStatus procedure.
  480. /ResourceStatus {
  481.     dup .GetInstance {
  482.       exch pop dup 1 get exch 2 get true
  483.     } {
  484.       .ResourceFileStatus
  485.     } ifelse
  486. } bind
  487. /.ResourceFileStatus {
  488.     .ResourceFile { closefile 2 -1 true } { pop false } ifelse
  489. } bind
  490. /ResourceForAll {
  491.         % Construct a new procedure to hold the arguments.
  492.         % All objects constructed here must be in local VM to avoid
  493.         % a possible invalidaccess.
  494.     currentdict 4 .localvmpackedarray    % [template proc scratch resdict]
  495.         % We must pop the resource dictionary off the dict stack
  496.         % when doing the actual iteration, and restore it afterwards.
  497.     .currentglobal not {
  498.       .LocalInstances length 0 ne {
  499.         % We must do local instances, and do them first.
  500.         //.localresourceforall {exec} 0 get 3 .localvmpackedarray cvx
  501.         .LocalInstances exch {forall} 0 get 1 index 0 get
  502.         currentdict end 3 .execn begin
  503.       } if
  504.     } if
  505.         % Do global instances next.
  506.     //.globalresourceforall {exec} 0 get 3 .localvmpackedarray cvx
  507.     .Instances exch cvx {forall} 0 get 1 index 0 get
  508.     currentdict end 3 .execn begin
  509.         mark                                             % args [
  510.         Category .namestring .file_name_separator concatstrings
  511.         2 index 0 get                                    % args [ (c/) (t)
  512.         dup length 3 1 roll                              % args [ l (c/) (t)
  513.         concatstrings                                    % args [ l (c/t)
  514.     [ 
  515.       true /LIBPATH .systemvar 3 index
  516.       .generate_dir_list_templates_with_length       % args (t) [ l [(pt) Lp ...]
  517.         % also add on the Resources as specified by the GenericResourceDir
  518.           true [ currentsystemparams /GenericResourceDir get]
  519.       counttomark 1 add index .generate_dir_list_templates_with_length
  520.             % Resource files on OpenVMS require a separate template (gs:[dir.*]*)
  521.           true [ currentsystemparams /GenericResourceDir get]
  522.       counttomark 1 add index .file_name_separator (*)
  523.           concatstrings concatstrings .generate_dir_list_templates_with_length
  524.       ] exch pop
  525.     dup length 1 sub 0 exch 2 exch {                 % args [ l [] i
  526.       2 copy get                                     % args [ l [] i (pt)
  527.       exch 2 index exch 1 add get                    % args [ l [] (pt) Lp
  528.       exch                                           % args [ l [] Lp (pt)
  529.  
  530.       {                                              % args [ l [] Lp (pf)
  531.         dup length                                   % args [ l [] Lp (pf) Lpf
  532.         2 index sub                                  % args [ l [] Lp (pf) Lf
  533.         2 index exch                                 % args [ l [] Lp (pf) Lp Lf
  534.         getinterval cvn dup                          % args [ l [] Lp /n /n
  535.         5 2 roll                                     % args [ /n /n l [] Lp
  536.       } //.rfnstring filenameforall
  537.       pop                                            % args [ /n1 /n1 ... /nN /nN l []
  538.     } for                                            % args [ /n1 /n1 ... /nN /nN l []
  539.     pop pop
  540.     .dicttomark % An easy way to exclude duplicates. % args <</n/n>>
  541.       % {
  542.       { pop } 0 get
  543.           2 index 2 get { cvs 0 } aload pop 5 index
  544.           //.externalresourceforall {exec} 0 get
  545.           % }
  546.         7 .localvmpackedarray cvx
  547.         3 2 roll pop % args
  548.     { forall } 0 get
  549.       currentdict end 2 .execn begin
  550. } bind
  551. /.file_name_is_iodevice_or_absolute
  552. { {
  553.     dup length 0 gt {
  554.       dup 0 get (%) 0 get eq {
  555.         pop true exit
  556.       } if
  557.     } if
  558.     .file_name_is_absolute exit
  559.   } loop
  560. } bind def
  561. /ResourceFileName
  562.       {                                             % /in (scr)
  563.         exch //.rfnstring cvs                       % (scr) (n)
  564.             /GenericResourcePathSep getsystemparam exch % (scr) (/) (n)
  565.             Category .namestring                        % (scr) (/) (n) (c)
  566.             3 1 roll                                    % (scr) (c) (/) (n)
  567.         concatstrings concatstrings                 % (scr) (c/n)
  568.             /GenericResourceDir getsystemparam //.file_name_is_iodevice_or_absolute exec not {
  569.               /GenericResourceDir getsystemparam exch concatstrings
  570.           findlibfile
  571.           {                                         % (scr) (p/c/n) file
  572.             pop exch copy true                      % (p/c/n) true
  573.           } {                                       % (scr) (c/n)
  574.             false                                   % (scr) (c/n) false
  575.           } ifelse
  576.         } {                                         % (scr) (c/n)
  577.           false                                     % (scr) (c/n) false
  578.         } ifelse
  579.         not {                                       % (scr) (c/n)
  580.               /GenericResourceDir getsystemparam        % (scr) (c/n) (d/)
  581.               dup length exch                           % (scr) (c/n) Ld (d/)
  582.               3 index copy pop                          % (scr') (c/n) Ld
  583.               1 index length                            % (scr') (c/n) Ld Lcn
  584.               3 index 3 copy pop                        % (scr') (c/n) Ld Lcn (scr') Ld Lcn
  585.               getinterval                               % (scr') (c/n) Ld Lcn (scr[Ld:Lcn])
  586.               4 3 roll exch                             % (scr') Ld Lcn (c/n) (scr[Ld:Lcn])
  587.               copy pop                                  % (scr'') Ld Lcn
  588.               add 0 exch getinterval                    % (scr''[0:Ld+Lcn])
  589.         } if
  590.       } bind
  591.  
  592.         % Additional entries
  593.  
  594. % Unfortunately, we can't create the real .Instances dictionary now,
  595. % because if someone copies the Generic category (which pp. 95-96 of the
  596. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  597. % the .Instances.  Instead, we have to create .Instances on demand,
  598. % just like the entry in localinstancedict.
  599. % We also have to prevent anyone from creating instances of Generic itself.
  600. /.Instances //.emptydict
  601.  
  602. /.LocalInstances
  603.     { localinstancedict Category .knownget not { //.emptydict } if
  604.     } bind
  605. /.GetInstance
  606.     { currentglobal
  607.        { .Instances exch .knownget }
  608.        { .LocalInstances 1 index .knownget
  609.           { exch pop true }
  610.           { .Instances exch .knownget }
  611.          ifelse
  612.        }
  613.       ifelse
  614.     } bind
  615. /.CheckResource
  616.     { true
  617.     } bind
  618. /.vmused {
  619.         % - .vmused <usedvalue>
  620.         % usedvalue = vmstatus in global + vmstatus in local.
  621.   0 2 {
  622.     .currentglobal not .setglobal
  623.     vmstatus pop exch pop add
  624.   } repeat
  625. } bind def
  626. /.DoLoadResource {
  627.         % .LoadResource may push entries on the operand stack.
  628.         % It is an undocumented feature of Adobe implementations,
  629.         % which we must match for the sake of some badly written
  630.         % font downloading code, that such entries are popped
  631.         % automatically.
  632.     count 1 index cvlit .vmused
  633.         % Stack: key count litkey memused
  634.     {.LoadResource} 4 1 roll 4 .execn
  635.         % Stack: ... count key memused
  636.     .vmused exch sub
  637.     1 index .getvminstance not {
  638.       pop dup .undefinedresource    % didn't load
  639.     } if
  640.     dup 1 1 put
  641.     2 3 -1 roll put
  642.         % Stack: ... count key
  643.     exch count 1 sub exch sub {exch pop} repeat
  644. } bind
  645. /.LoadResource
  646.     { dup .ResourceFile
  647.        { exch pop currentglobal
  648.           { .runresource }
  649.           { true setglobal { .runresource } stopped false setglobal { stop } if }
  650.          ifelse
  651.        }
  652.        { dup .undefinedresource
  653.        }
  654.      ifelse
  655.     } bind
  656. /.ResourceFile
  657.         {
  658.           Category //.rfnstring cvs length                      % key l
  659.           dup //.rfnstring dup length 2 index sub               % key l l (buf) L-l
  660.           3 2 roll exch getinterval                             % key l ()
  661.           .file_name_directory_separator exch copy length add   % key l1
  662.           dup //.rfnstring dup length 2 index sub               % key l1 l1 (buf) L-l
  663.           3 2 roll exch getinterval                             % key l1 ()
  664.           2 index exch cvs length add                           % key l2
  665.           //.rfnstring exch 0 exch getinterval                  % key (relative_path)
  666.           .libfile {
  667.             exch pop true
  668.           } {
  669.             pop
  670.             currentdict /ResourceFileName known {
  671.           mark 1 index //.rfnstring { ResourceFileName } .internalstopped {
  672.             cleartomark false
  673.           } {
  674.             (r) { file } .internalstopped {
  675.               cleartomark false
  676.         } {
  677.               exch pop exch pop true
  678.             } ifelse
  679.           } ifelse
  680.          } {
  681.            pop false
  682.          } ifelse
  683.           } ifelse
  684.     } bind
  685.  
  686.  
  687.  
  688. .dicttomark
  689. /Category defineresource pop
  690.  
  691. % Fill in the rest of the Category category.
  692. /Category /Category findresource dup
  693. /Generic /Category findresource begin {
  694.   /FindResource /ResourceForAll /ResourceStatus /.ResourceFileStatus
  695.   /UndefineResource /ResourceFileName
  696.   /.ResourceFile /.LoadResource /.DoLoadResource
  697. } { dup load put dup } forall
  698. pop readonly pop end
  699.  
  700. (END GENERIC) VMDEBUG
  701.  
  702. % Define the fixed categories.
  703.  
  704. mark
  705.     % Non-Type categories with existing entries.
  706.  /ColorSpaceFamily
  707.    { }    % These must be deferred, because optional features may add some.
  708.  /Emulator
  709.    mark EMULATORS { cvn } forall .packtomark
  710.  /Filter
  711.    { }    % These must be deferred, because optional features may add some.
  712.  /IODevice
  713.     % Loop until the .getiodevice gets a rangecheck.
  714.    errordict /rangecheck 2 copy get
  715.    errordict /rangecheck { pop stop } put    % pop the command
  716.    mark 0 { {
  717.     dup .getiodevice dup null eq { pop } { exch } ifelse 1 add
  718.    } loop} .internalstopped
  719.    pop pop pop .packtomark
  720.    4 1 roll put
  721.    .clearerror
  722.     % Type categories listed in the Red Book.
  723.  /ColorRenderingType
  724.    { }    % These must be deferred, because optional features may add some.
  725.  /FMapType
  726.    { }    % These must be deferred, because optional features may add some.
  727.  /FontType
  728.    { }    % These must be deferred, because optional features may add some.
  729.  /FormType
  730.    { }    % These must be deferred, because optional features may add some.
  731.  /HalftoneType
  732.    { }    % These must be deferred, because optional features may add some.
  733.  /ImageType
  734.    { }    % Deferred, optional features may add some.
  735.  /PatternType
  736.    { }  % Deferred, optional features may add some.
  737.     % Type categories added since the Red Book.
  738.  /setsmoothness where {
  739.    pop /ShadingType { }    % Deferred, optional features may add some.
  740.  } if
  741. counttomark 2 idiv
  742.  { mark
  743.  
  744.         % Standard entries
  745.  
  746.         % We'd like to prohibit defineresource,
  747.         % but because optional features may add entries, we can't.
  748.         % We can at least require that the key and value match.
  749.    /DefineResource
  750.     { currentglobal not
  751.        { /defineresource cvx /invalidaccess signaloperror }
  752.        { 2 copy ne
  753.           { /defineresource cvx /rangecheck signaloperror }
  754.           { dup .Instances 4 -2 roll .growput }
  755.          ifelse
  756.        }
  757.       ifelse
  758.     } bind
  759.    /UndefineResource
  760.     { /undefineresource cvx /invalidaccess signaloperror } bind
  761.    /FindResource
  762.     { .Instances 1 index .knownget
  763.        { exch pop }
  764.        { /findresource cvx .undefinedresource }
  765.       ifelse
  766.     } bind
  767.    /ResourceStatus
  768.     { .Instances exch known { 0 0 true } { false } ifelse } bind
  769.    /ResourceForAll
  770.     /Generic .findcategory /ResourceForAll load end
  771.  
  772.         % Additional entries
  773.  
  774.    counttomark 2 add -1 roll
  775.    dup length dict dup begin exch { dup def } forall end
  776.         % We'd like to make the .Instances readonly here,
  777.         % but because optional features may add entries, we can't.
  778.    /.Instances exch
  779.    /.LocalInstances    % used by ResourceForAll
  780.     0 dict def
  781.  
  782.    .dicttomark /Category defineresource pop
  783.  } repeat pop
  784.  
  785. (END FIXED) VMDEBUG
  786.  
  787. % Define the other built-in categories.
  788.  
  789. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  790.  { counttomark 2 idiv 2 add        % .Instances, Category
  791.    /Generic /Category findresource dup maxlength 3 -1 roll add
  792.    dict .copydict begin
  793.    counttomark 2 idiv { def } repeat pop    % pop the mark
  794.    currentdict end /Category defineresource pop
  795.  } bind def
  796.  
  797. /ColorRendering mark /InstanceType /dicttype .definecategory
  798. % ColorSpace is defined below
  799. % Encoding is defined below
  800. % Font is defined below
  801. /Form mark /InstanceType /dicttype .definecategory
  802. /Halftone mark /InstanceType /dicttype .definecategory
  803. /Pattern mark /InstanceType /dicttype .definecategory
  804. /ProcSet mark /InstanceType /dicttype .definecategory
  805. % Added since the Red Book:
  806. /ControlLanguage mark /InstanceType /dicttype .definecategory
  807. /HWOptions mark /InstanceType /dicttype .definecategory
  808. /Localization mark /InstanceType /dicttype .definecategory
  809. /OutputDevice mark /InstanceType /dicttype .definecategory
  810. /PDL mark /InstanceType /dicttype .definecategory
  811. % CIDFont, CIDMap, and CMap are defined in gs_cidfn.ps
  812. % FontSet is defined in gs_cff.ps
  813. % IdiomSet is defined in gs_ll3.ps
  814. % InkParams and TrapParams are defined in gs_trap.ps
  815.  
  816. (END MISC) VMDEBUG
  817.  
  818. % Define the ColorSpace category.
  819.  
  820. /.defaultcsnames mark
  821.   /DefaultGray 0
  822.   /DefaultRGB 1
  823.   /DefaultCMYK 2
  824. .dicttomark readonly def
  825.  
  826. % The "hooks" are no-ops here, redefined in LL3.
  827. /.definedefaultcs {    % <index> <value> .definedefaultcs -
  828.   pop pop
  829. } bind def
  830. /.undefinedefaultcs {    % <index> .undefinedefaultcs -
  831.   pop
  832. } bind def
  833.  
  834. /ColorSpace mark
  835.  
  836. /InstanceType /arraytype
  837.  
  838. % We keep track of whether there are any local definitions for any of
  839. % the Default keys.  This information must get saved and restored in
  840. % parallel with the local instance dictionary, so it must be stored in
  841. % local VM.
  842. userdict /.localcsdefaults false put
  843.  
  844. /DefineResource {
  845.   2 copy /Generic /Category findresource /DefineResource get exec
  846.   exch pop
  847.   exch //.defaultcsnames exch .knownget {
  848.     1 index .definedefaultcs
  849.     currentglobal not { .userdict /.localcsdefaults true put } if
  850.   } if
  851. } bind
  852.  
  853. /UndefineResource {
  854.   dup /Generic /Category findresource /UndefineResource get exec
  855.   //.defaultcsnames 1 index .knownget {
  856.     % Stack: resname index
  857.     currentglobal {
  858.       .undefinedefaultcs pop
  859.     } {
  860.     % We removed the local definition, but there might be a global one.
  861.       exch .GetInstance {
  862.     0 get .definedefaultcs
  863.       } {
  864.     .undefinedefaultcs
  865.       } ifelse
  866.     % Recompute .localcsdefaults by scanning.  This is rarely needed.
  867.       .userdict /.localcsdefaults false //.defaultcsnames {
  868.     pop .LocalInstances exch known { pop true exit } if
  869.       } forall put
  870.     } ifelse
  871.   } {
  872.     pop
  873.   } ifelse
  874. } bind
  875.  
  876. .definecategory            % ColorSpace
  877.  
  878. % Define the Encoding category.
  879.  
  880. /Encoding mark
  881.  
  882. /InstanceType /arraytype
  883.  
  884. % Handle already-registered encodings, including lazily loaded encodings
  885. % that aren't loaded yet.
  886.  
  887. /.Instances mark
  888.   EncodingDirectory
  889.    { dup length 256 eq { [ exch readonly 0 -1 ] } { pop [null 2 -1] } ifelse
  890.    } forall
  891. .dicttomark
  892.  
  893. /.ResourceFileDict mark
  894.   EncodingDirectory
  895.    { dup length 256 eq { pop pop } { 0 get } ifelse
  896.    } forall
  897. .dicttomark
  898.  
  899. /ResourceFileName
  900.  { .ResourceFileDict 2 index .knownget
  901.     { exch copy exch pop }
  902.     { /Generic /Category findresource /ResourceFileName get exec }
  903.    ifelse
  904.  } bind
  905.  
  906. .definecategory            % Encoding
  907.  
  908. % Make placeholders in level2dict for the redefined Encoding operators,
  909. % so that they will be swapped properly when we switch language levels.
  910.  
  911. /.findencoding /.findencoding load def
  912. /findencoding /findencoding load def
  913. /.defineencoding /.defineencoding load def
  914.  
  915. (END ENCODING) VMDEBUG
  916.  
  917. % Define the Font category.
  918.  
  919. /.fontstatus {        % <fontname> .fontstatus <fontname> <found>
  920.   {        % Create a loop context just so we can exit it early.
  921.         % Check Fontmap.
  922.     Fontmap 1 index .knownget {
  923.       {
  924.     dup type /nametype eq {
  925.       .fontstatus { pop null exit } if
  926.     } {
  927.       dup type /stringtype eq {
  928.         findlibfile { closefile pop null exit } if pop
  929.       } {
  930.         % Procedure, assume success.
  931.         pop null exit
  932.       } ifelse
  933.     } ifelse
  934.       } forall dup null eq { pop true exit } if
  935.     } if
  936.         % Convert names to strings; give up on other types.
  937.     dup type /nametype eq { .namestring } if
  938.     dup type /stringtype ne { false exit } if
  939.         % Check the resource directory.
  940.     dup .fonttempstring /FontResourceDir getsystemparam .genericrfn
  941.     status {
  942.       pop pop pop pop true exit
  943.     } if
  944.         % Check for a file on the search path with the same name
  945.         % as the font.
  946.     findlibfile { closefile true exit } if
  947.         % Scan a FONTPATH directory and try again.
  948.     .scannextfontdir not { false exit } if
  949.   } loop
  950. } bind def
  951.  
  952. /Font mark
  953.  
  954. /InstanceType /dicttype
  955.  
  956. /DefineResource
  957.     { 2 copy //definefont exch pop
  958.       /Generic /Category findresource /DefineResource get exec
  959.     } bind
  960. /UndefineResource
  961.     { dup //undefinefont
  962.       /Generic /Category findresource /UndefineResource get exec
  963.     } bind
  964. /FindResource {
  965.     dup .getvminstance {
  966.       exch pop 0 get
  967.     } {
  968.       dup ResourceStatus {
  969.         pop 1 gt { .loadfontresource } { .GetInstance pop 0 get } ifelse
  970.       } {
  971.         .loadfontresource
  972.       } ifelse
  973.     } ifelse
  974. } bind
  975. /ResourceForAll {
  976.     { .scannextfontdir not { exit } if } loop
  977.     /Generic /Category findresource /ResourceForAll get exec
  978. } bind
  979. /.ResourceFileStatus {
  980.     .fontstatus { pop 2 -1 true } { pop false } ifelse
  981. } bind
  982.  
  983. /.loadfontresource {
  984.     dup vmstatus pop exch pop exch
  985.         % Hack: rebind .currentresourcefile so that all calls of
  986.         % definefont will know these are built-in fonts.
  987.     currentfile {pop //findfont exec} .execasresource  % (findfont is a procedure)
  988.     exch vmstatus pop exch pop exch sub
  989.         % stack: name font vmused
  990.         % findfont has the prerogative of not calling definefont
  991.         % in certain obscure cases of font substitution.
  992.     2 index .getvminstance {
  993.       dup 1 1 put
  994.       2 3 -1 roll put
  995.     } {
  996.       pop
  997.     } ifelse exch pop
  998. } bind
  999.  
  1000. /.Instances FontDirectory length 2 mul dict
  1001.  
  1002. .definecategory            % Font
  1003.  
  1004. % Redefine font "operators".
  1005. /.definefontmap
  1006.  { /Font /Category findresource /.Instances get
  1007.    dup 3 index known
  1008.     { pop
  1009.     }
  1010.     { 2 index
  1011.         % Make sure we create the array in global VM.
  1012.       .currentglobal true .setglobal
  1013.       [null 2 -1] exch .setglobal
  1014.       .growput
  1015.     }
  1016.    ifelse
  1017.    //.definefontmap exec
  1018.  } bind def
  1019.  
  1020. % Make sure the old definitions are still in systemdict so that
  1021. % they will get bound properly.
  1022. systemdict begin
  1023.   /.origdefinefont /definefont load def
  1024.   /.origundefinefont /undefinefont load def
  1025.   /.origfindfont /findfont load def
  1026. end
  1027. /definefont {
  1028.   { /Font defineresource } stopped {
  1029.       /definefont cvx $error /errorname get signalerror
  1030.   } if
  1031. } bind odef
  1032. /undefinefont {
  1033.   /Font undefineresource
  1034. } bind odef
  1035. % The Red Book requires that findfont be a procedure, not an operator,
  1036. % but it still needs to restore the stacks reliably if it fails.
  1037. /.findfontop {
  1038.   { /Font findresource } stopped {
  1039.     pop /findfont $error /errorname get signalerror
  1040.   } if
  1041. } bind odef
  1042. /findfont {
  1043.   .findfontop
  1044. } bind def    % Must be a procedure, not an operator
  1045.  
  1046. % Remove initialization utilities.
  1047. currentdict /.definecategory .undef
  1048. currentdict /.emptydict .undef
  1049.  
  1050. end                % level2dict
  1051.  
  1052. % Convert deferred resources after we finally switch to Level 2.
  1053.  
  1054. /.fixresources {
  1055.     % Encoding resources
  1056.   EncodingDirectory
  1057.    { dup length 256 eq
  1058.       { /Encoding defineresource pop }
  1059.       { pop pop }
  1060.      ifelse
  1061.    } forall
  1062.   /.findencoding {
  1063.     { /Encoding findresource } stopped {
  1064.       pop /findencoding $error /errorname get signalerror
  1065.     } if
  1066.   } bind def
  1067.   /findencoding /.findencoding load def        % must be a procedure
  1068.   /.defineencoding { /Encoding defineresource pop } bind def
  1069.     % ColorRendering resources and ProcSet
  1070.   systemdict /ColorRendering .knownget {
  1071.     /ColorRendering exch /ProcSet defineresource pop
  1072.     systemdict /ColorRendering undef
  1073.     /DefaultColorRendering currentcolorrendering /ColorRendering defineresource pop
  1074.   } if
  1075.     % ColorSpace resources
  1076.   systemdict /CIEsRGB .knownget {
  1077.     /sRGB exch /ColorSpace defineresource pop
  1078.     systemdict /CIEsRGB undef
  1079.   } if
  1080.     % ColorSpaceFamily resources
  1081.   colorspacedict { pop dup /ColorSpaceFamily defineresource pop } forall
  1082.     % Filter resources
  1083.   filterdict { pop dup /Filter defineresource pop } forall
  1084.     % FontType and FMapType resources
  1085.   buildfontdict { pop dup /FontType defineresource pop } forall
  1086.   mark
  1087.     buildfontdict 0 known { 2 3 4 5 6 7 8 } if
  1088.     buildfontdict 9 known { 9 } if
  1089.   counttomark { dup /FMapType defineresource pop } repeat pop
  1090.     % FormType resources
  1091.   .formtypes { pop dup /FormType defineresource pop } forall
  1092.     % HalftoneType resources
  1093.   .halftonetypes { pop dup /HalftoneType defineresource pop } forall
  1094.     % ColorRenderingType resources
  1095.   .colorrenderingtypes {pop dup /ColorRenderingType defineresource pop} forall
  1096.     % ImageType resources
  1097.   .imagetypes { pop dup /ImageType defineresource pop } forall
  1098.     % PatternType resources
  1099.   .patterntypes { pop dup /PatternType defineresource pop } forall
  1100.     % Make the fixed resource categories immutable.
  1101.   /.shadingtypes where {
  1102.     pop .shadingtypes { pop dup /ShadingType defineresource pop } forall
  1103.   } if
  1104.   [ /ColorSpaceFamily /Emulator /Filter /IODevice /ColorRenderingType
  1105.     /FMapType /FontType /FormType /HalftoneType /ImageType /PatternType
  1106.     /.shadingtypes where { pop /ShadingType } if
  1107.   ] {
  1108.     /Category findresource
  1109.     dup /.Instances get readonly pop
  1110.     .LocalInstances readonly pop
  1111.     readonly pop
  1112.   } forall
  1113.     % clean up
  1114.   systemdict /.fixresources undef
  1115. } bind def
  1116.  
  1117. %% Replace 1 (gs_resmp.ps)
  1118. (gs_resmp.ps)  dup runlibfile VMDEBUG
  1119.